

import org.apache.commons.lang.StringEscapeUtils;
import org.apache.ibatis.builder.BuilderException;
import org.apache.ibatis.builder.SqlSourceBuilder;
import org.apache.ibatis.builder.xml.XMLMapperEntityResolver;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.parsing.XNode;
import org.apache.ibatis.parsing.XPathParser;
import org.apache.ibatis.scripting.xmltags.*;
import org.apache.ibatis.session.Configuration;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DynamicSqlParser {

    public static BoundSql getRuningSql(String sql, Map params, String type) {
        Configuration configuration = new Configuration();
        configuration.setDatabaseId("");
        if (type != null && type.equals("1")) {
            sql = StringEscapeUtils.escapeXml(sql);
        }

        String xmlStr = "<select id=\"getSimpList\" parameterType=\"java.util.Map\">\n" + sql + "  </select>";

        /**
         * @see XMLLanguageDriver#createSqlSource(Configuration, String, Class)
         */
        XPathParser parser = new XPathParser(xmlStr, false, null, new XMLMapperEntityResolver());
        XNode contents = parser.evalNode("/select");

        /**
         * @see org.apache.ibatis.scripting.xmltags.XMLScriptBuilder
         */
        XMLScriptBuilder xmlScriptBuilder = new XMLScriptBuilder(configuration, contents);
        SqlSource sqlSource = xmlScriptBuilder.parseScriptNode();

        /**
         * 获取BoundSql
         */
        return sqlSource.getBoundSql(params);


    }


    /**
     * @see org.apache.ibatis.scripting.xmltags.DynamicSqlSource
     */
    static class DynamicSqlSource implements SqlSource {
        private Configuration configuration;
        private SqlNode rootSqlNode;

        public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
            this.configuration = configuration;
            this.rootSqlNode = rootSqlNode;
        }

        @Override
        public BoundSql getBoundSql(Object parameterObject) {
            /**
             * 1、使用ognl表达式，替换掉 ${...} 类型的值
             * 2、根据调用数据《擦除》xml标签
             */
            DynamicContext context = new DynamicContext(configuration, parameterObject);
            rootSqlNode.apply(context);
            log.debug("sql after do ognl, sql = {}", context.getSql());

            /**
             *  3、替换占位符 井{..} 为 占位符 ?，同时解析出绑定的参数
             */
            SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
            Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
            SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());

            /**
             * 4、创建 BoundSql 对象
             */
            BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
            for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {
                boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
            }

            return boundSql;
        }
    }

    /**
     * @see org.apache.ibatis.scripting.xmltags.XMLScriptBuilder
     */
    static class XMLScriptBuilder {
        protected final Configuration configuration;
        private XNode context;
        private boolean isDynamic;

        public XMLScriptBuilder(Configuration configuration, XNode context) {
            this.configuration = configuration;
            this.context = context;
        }

        public SqlSource parseScriptNode() {
            List<SqlNode> contents = parseDynamicTags(context);
            MixedSqlNode rootSqlNode = new MixedSqlNode(contents);

            SqlSource sqlSource = null;
            sqlSource = new DynamicSqlSource(configuration, rootSqlNode);

            return sqlSource;
        }

        private List<SqlNode> parseDynamicTags(XNode node) {
            List<SqlNode> contents = new ArrayList<SqlNode>();
            NodeList children = node.getNode().getChildNodes();
            for (int i = 0; i < children.getLength(); i++) {
                XNode child = node.newXNode(children.item(i));
                if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
                    String data = child.getStringBody("");
                    TextSqlNode textSqlNode = new TextSqlNode(data);
                    if (textSqlNode.isDynamic()) { // 存在 ${} 占位符
                        contents.add(textSqlNode);
                        isDynamic = true;
                    } else {
                        contents.add(new StaticTextSqlNode(data));
                    }
                } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
                    // 解析标签
                    String nodeName = child.getNode().getNodeName();

                    // 节点处理器
                    NodeHandler handler = nodeHandlers(nodeName);
                    if (handler == null) {
                        throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
                    }
                    handler.handleNode(child, contents);
                    isDynamic = true;
                }
            }

            return contents;
        }

        NodeHandler nodeHandlers(String nodeName) {
            Map<String, NodeHandler> map = new HashMap<String, NodeHandler>();
            map.put("trim", new TrimHandler());
            map.put("where", new WhereHandler());
            map.put("set", new SetHandler());
            map.put("foreach", new ForEachHandler());
            map.put("if", new IfHandler());
            map.put("choose", new ChooseHandler());
            map.put("when", new IfHandler());
            map.put("otherwise", new OtherwiseHandler());
            map.put("bind", new BindHandler());

            return map.get(nodeName);
        }

        private interface NodeHandler {
            void handleNode(XNode nodeToHandle, List<SqlNode> targetContents);
        }

        private class BindHandler implements NodeHandler {
            public BindHandler() {
                // Prevent Synthetic Access
            }

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                final String name = nodeToHandle.getStringAttribute("name");
                final String expression = nodeToHandle.getStringAttribute("value");
                final VarDeclSqlNode node = new VarDeclSqlNode(name, expression);
                targetContents.add(node);
            }
        }

        private class TrimHandler implements NodeHandler {
            public TrimHandler() {
                // Prevent Synthetic Access
            }

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> contents = parseDynamicTags(nodeToHandle);  // 递归
                MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
                String prefix = nodeToHandle.getStringAttribute("prefix");
                String prefixOverrides = nodeToHandle.getStringAttribute("prefixOverrides");
                String suffix = nodeToHandle.getStringAttribute("suffix");
                String suffixOverrides = nodeToHandle.getStringAttribute("suffixOverrides");
                TrimSqlNode trim = new TrimSqlNode(configuration, mixedSqlNode, prefix, prefixOverrides, suffix, suffixOverrides);
                targetContents.add(trim);
            }
        }

        private class WhereHandler implements NodeHandler {
            public WhereHandler() {
                // Prevent Synthetic Access
            }

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> contents = parseDynamicTags(nodeToHandle); // 递归
                MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
                WhereSqlNode where = new WhereSqlNode(configuration, mixedSqlNode);
                targetContents.add(where);
            }
        }

        private class SetHandler implements NodeHandler {
            public SetHandler() {
                // Prevent Synthetic Access
            }

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> contents = parseDynamicTags(nodeToHandle);  // 递归
                MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
                SetSqlNode set = new SetSqlNode(configuration, mixedSqlNode);
                targetContents.add(set);
            }
        }

        private class ForEachHandler implements NodeHandler {
            public ForEachHandler() {
                // Prevent Synthetic Access
            }

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> contents = parseDynamicTags(nodeToHandle);  // 递归
                MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
                String collection = nodeToHandle.getStringAttribute("collection");
                String item = nodeToHandle.getStringAttribute("item");
                String index = nodeToHandle.getStringAttribute("index");
                String open = nodeToHandle.getStringAttribute("open");
                String close = nodeToHandle.getStringAttribute("close");
                String separator = nodeToHandle.getStringAttribute("separator");
                ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, index, item, open, close, separator);
                targetContents.add(forEachSqlNode);
            }
        }

        private class IfHandler implements NodeHandler {
            public IfHandler() {
                // Prevent Synthetic Access
            }

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> contents = parseDynamicTags(nodeToHandle);
                MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
                String test = nodeToHandle.getStringAttribute("test");
                IfSqlNode ifSqlNode = new IfSqlNode(mixedSqlNode, test);
                targetContents.add(ifSqlNode);
            }
        }

        private class OtherwiseHandler implements NodeHandler {
            public OtherwiseHandler() {
                // Prevent Synthetic Access
            }

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> contents = parseDynamicTags(nodeToHandle);
                MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
                targetContents.add(mixedSqlNode);
            }
        }

        private class ChooseHandler implements NodeHandler {
            public ChooseHandler() {
                // Prevent Synthetic Access
            }

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> whenSqlNodes = new ArrayList<SqlNode>();
                List<SqlNode> otherwiseSqlNodes = new ArrayList<SqlNode>();
                handleWhenOtherwiseNodes(nodeToHandle, whenSqlNodes, otherwiseSqlNodes);
                SqlNode defaultSqlNode = getDefaultSqlNode(otherwiseSqlNodes);
                ChooseSqlNode chooseSqlNode = new ChooseSqlNode(whenSqlNodes, defaultSqlNode);
                targetContents.add(chooseSqlNode);
            }

            private void handleWhenOtherwiseNodes(XNode chooseSqlNode, List<SqlNode> ifSqlNodes, List<SqlNode> defaultSqlNodes) {
                List<XNode> children = chooseSqlNode.getChildren();
                for (XNode child : children) {
                    String nodeName = child.getNode().getNodeName();
                    NodeHandler handler = nodeHandlers(nodeName);
                    if (handler instanceof IfHandler) {
                        handler.handleNode(child, ifSqlNodes);
                    } else if (handler instanceof OtherwiseHandler) {
                        handler.handleNode(child, defaultSqlNodes);
                    }
                }
            }

            private SqlNode getDefaultSqlNode(List<SqlNode> defaultSqlNodes) {
                SqlNode defaultSqlNode = null;
                if (defaultSqlNodes.size() == 1) {
                    defaultSqlNode = defaultSqlNodes.get(0);
                } else if (defaultSqlNodes.size() > 1) {
                    throw new BuilderException("Too many default (otherwise) elements in choose statement.");
                }
                return defaultSqlNode;
            }
        }
    }


}
